home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / perl5 / Net / DBus.pm
Encoding:
Perl POD Document  |  2008-02-20  |  17.0 KB  |  749 lines
  1. # -*- perl -*-
  2. #
  3. # Copyright (C) 2004-2006 Daniel P. Berrange
  4. #
  5. # This program is free software; You can redistribute it and/or modify
  6. # it under the same terms as Perl itself. Either:
  7. #
  8. # a) the GNU General Public License as published by the Free
  9. #   Software Foundation; either version 2, or (at your option) any
  10. #   later version,
  11. #
  12. # or
  13. #
  14. # b) the "Artistic License"
  15. #
  16. # The file "COPYING" distributed along with this file provides full
  17. # details of the terms and conditions of the two licenses.
  18.  
  19. =pod
  20.  
  21. =head1 NAME
  22.  
  23. Net::DBus - Perl extension for the DBus message system
  24.  
  25. =head1 SYNOPSIS
  26.  
  27.  
  28.   ####### Attaching to the bus ###########
  29.  
  30.   use Net::DBus;
  31.  
  32.   # Find the most appropriate bus
  33.   my $bus = Net::DBus->find;
  34.  
  35.   # ... or explicitly go for the session bus
  36.   my $bus = Net::DBus->session;
  37.  
  38.   # .... or explicitly go for the system bus
  39.   my $bus = Net::DBus->system
  40.  
  41.  
  42.   ######## Accessing remote services #########
  43.  
  44.   # Get a handle to the HAL service
  45.   my $hal = $bus->get_service("org.freedesktop.Hal");
  46.  
  47.   # Get the device manager
  48.   my $manager = $hal->get_object("/org/freedesktop/Hal/Manager",
  49.                  "org.freedesktop.Hal.Manager");
  50.  
  51.   # List devices
  52.   foreach my $dev (@{$manager->GetAllDevices}) {
  53.       print $dev, "\n";
  54.   }
  55.  
  56.  
  57.   ######### Providing services ##############
  58.  
  59.   # Register a service known as 'org.example.Jukebox'
  60.   my $service = $bus->export_service("org.example.Jukebox");
  61.  
  62.  
  63. =head1 DESCRIPTION
  64.  
  65. Net::DBus provides a Perl API for the DBus message system.
  66. The DBus Perl interface is currently operating against
  67. the 0.32 development version of DBus, but should work with
  68. later versions too, providing the API changes have not been
  69. too drastic.
  70.  
  71. Users of this package are either typically, service providers
  72. in which case the L<Net::DBus::Service> and L<Net::DBus::Object>
  73. modules are of most relevance, or are client consumers, in which
  74. case L<Net::DBus::RemoteService> and L<Net::DBus::RemoteObject>
  75. are of most relevance.
  76.  
  77. =head1 METHODS
  78.  
  79. =over 4
  80.  
  81. =cut
  82.  
  83. package Net::DBus;
  84.  
  85. use 5.006;
  86. use strict;
  87. use warnings;
  88.  
  89. BEGIN {
  90.     our $VERSION = '0.33.6';
  91.     require XSLoader;
  92.     XSLoader::load('Net::DBus', $VERSION);
  93. }
  94.  
  95. use Net::DBus::Binding::Bus;
  96. use Net::DBus::Service;
  97. use Net::DBus::RemoteService;
  98. use Net::DBus::Test::MockConnection;
  99. use Net::DBus::Binding::Value;
  100.  
  101. use vars qw($bus_system $bus_session);
  102.  
  103. use Exporter qw(import);
  104.  
  105. use vars qw(@EXPORT_OK %EXPORT_TAGS);
  106.  
  107. @EXPORT_OK = qw(dbus_int16 dbus_uint16 dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
  108.         dbus_byte dbus_boolean dbus_string dbus_double
  109.         dbus_object_path dbus_signature
  110.         dbus_struct dbus_array dbus_dict dbus_variant);
  111.  
  112. %EXPORT_TAGS = (typing => [qw(dbus_int16 dbus_uint16 dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
  113.                   dbus_byte dbus_boolean dbus_string dbus_double
  114.                   dbus_object_path dbus_signature
  115.                   dbus_struct dbus_array dbus_dict dbus_variant)]);
  116.  
  117. =item my $bus = Net::DBus->find(%params);
  118.  
  119. Search for the most appropriate bus to connect to and
  120. return a connection to it. The heuristic used for the
  121. search is
  122.  
  123.   - If DBUS_STARTER_BUS_TYPE is set to 'session' attach
  124.     to the session bus
  125.  
  126.   - Else If DBUS_STARTER_BUS_TYPE is set to 'system' attach
  127.     to the system bus
  128.  
  129.   - Else If DBUS_SESSION_BUS_ADDRESS is set attach to the
  130.     session bus
  131.  
  132.   - Else attach to the system bus
  133.  
  134. The optional C<params> hash can contain be used to specify
  135. connection options. The only support option at this time
  136. is C<nomainloop> which prevents the bus from being automatically
  137. attached to the main L<Net::DBus::Reactor> event loop.
  138.  
  139. =cut
  140.  
  141. sub find {
  142.     my $class = shift;
  143.  
  144.     if ($ENV{DBUS_STARTER_BUS_TYPE} &&
  145.     $ENV{DBUS_STARTER_BUS_TYPE} eq "session") {
  146.     return $class->session(@_);
  147.     } elsif ($ENV{DBUS_STARTER_BUS_TYPE} &&
  148.          $ENV{DBUS_STARTER_BUS_TYPE} eq "system") {
  149.     return $class->system(@_);
  150.     } elsif (exists $ENV{DBUS_SESSION_BUS_ADDRESS}) {
  151.     return $class->session(@_);
  152.     } else {
  153.     return $class->system;
  154.     }
  155. }
  156.  
  157. =item my $bus = Net::DBus->system(%params);
  158.  
  159. Return a handle for the system message bus. Note that the
  160. system message bus is locked down by default, so unless appropriate
  161. access control rules are added in /etc/dbus/system.d/, an application
  162. may access services, but won't be able to export services.
  163. The optional C<params> hash can contain be used to specify
  164. connection options. The only support option at this time
  165. is C<nomainloop> which prevents the bus from being automatically
  166. attached to the main L<Net::DBus::Reactor> event loop.
  167.  
  168. =cut
  169.  
  170. sub system {
  171.     my $class = shift;
  172.     my %params = @_;
  173.     if ($params{private}) {
  174.     return $class->_new(Net::DBus::Binding::Bus->new(type => &Net::DBus::Binding::Bus::SYSTEM, private => 1), @_);
  175.     }
  176.  
  177.     unless ($bus_system) {
  178.     $bus_system = $class->_new(Net::DBus::Binding::Bus->new(type => &Net::DBus::Binding::Bus::SYSTEM), @_);
  179.     }
  180.     return $bus_system
  181. }
  182.  
  183. =item my $bus = Net::DBus->session(%params);
  184.  
  185. Return a handle for the session message bus.
  186. The optional C<params> hash can contain be used to specify
  187. connection options. The only support option at this time
  188. is C<nomainloop> which prevents the bus from being automatically
  189. attached to the main L<Net::DBus::Reactor> event loop.
  190.  
  191. =cut
  192.  
  193. sub session {
  194.     my $class = shift;
  195.     my %params = @_;
  196.     if ($params{private}) {
  197.     return $class->_new(Net::DBus::Binding::Bus->new(type => &Net::DBus::Binding::Bus::SESSION, private => 1), @_);
  198.     }
  199.  
  200.     unless ($bus_session) {
  201.     $bus_session = $class->_new(Net::DBus::Binding::Bus->new(type => &Net::DBus::Binding::Bus::SESSION), @_);
  202.     }
  203.     return $bus_session;
  204. }
  205.  
  206.  
  207. =item my $bus = Net::DBus->test(%params);
  208.  
  209. Returns a handle for a virtual bus for use in unit tests. This bus does
  210. not make any network connections, but rather has an in-memory message
  211. pipeline. Consult L<Net::DBus::Test::MockConnection> for further details
  212. of how to use this special bus.
  213.  
  214. =cut
  215.  
  216. # NB. explicitly do *NOT* cache, since unit tests
  217. # should always have pristine state
  218. sub test {
  219.     my $class = shift;
  220.     return $class->_new(Net::DBus::Test::MockConnection->new());
  221. }
  222.  
  223. =item my $bus = Net::DBus->new($address, %params);
  224.  
  225. Return a connection to a specific message bus.  The C<$address>
  226. parameter must contain the address of the message bus to connect
  227. to. An example address for a session bus might look like
  228. C<unix:abstract=/tmp/dbus-PBFyyuUiVb,guid=191e0a43c3efc222e0818be556d67500>,
  229. while one for a system bus would look like C<unix:/var/run/dbus/system_bus_socket>.
  230. The optional C<params> hash can contain be used to specify
  231. connection options. The only support option at this time
  232. is C<nomainloop> which prevents the bus from being automatically
  233. attached to the main L<Net::DBus::Reactor> event loop.
  234.  
  235. =cut
  236.  
  237. sub new {
  238.     my $class = shift;
  239.     my $nomainloop = shift;
  240.     return $class->_new(Net::DBus::Binding::Bus->new(address => shift), @_);
  241. }
  242.  
  243. sub _new {
  244.     my $class = shift;
  245.     my $self = {};
  246.  
  247.     $self->{connection} = shift;
  248.     $self->{signals} = [];
  249.     $self->{services} = {};
  250.  
  251.     my %params = @_;
  252.  
  253.     bless $self, $class;
  254.  
  255.     unless ($params{nomainloop}) {
  256.     if (exists $INC{'Net/DBus/Reactor.pm'}) {
  257.         my $reactor = $params{reactor} ? $params{reactor} : Net::DBus::Reactor->main;
  258.         $reactor->manage($self->get_connection);
  259.     }
  260.     # ... Add support for GLib and POE
  261.     }
  262.  
  263.     $self->get_connection->add_filter(sub { return $self->_signal_func(@_); });
  264.  
  265.     $self->{bus} = Net::DBus::RemoteService->new($self, "org.freedesktop.DBus", "org.freedesktop.DBus");
  266.  
  267.     return $self;
  268. }
  269.  
  270. =item my $connection = $bus->get_connection;
  271.  
  272. Return a handle to the underlying, low level connection object
  273. associated with this bus. The returned object will be an instance
  274. of the L<Net::DBus::Binding::Bus> class. This method is not intended
  275. for use by (most!) application developers, so if you don't understand
  276. what this is for, then you don't need to be calling it!
  277.  
  278. =cut
  279.  
  280. sub get_connection {
  281.     my $self = shift;
  282.     return $self->{connection};
  283. }
  284.  
  285. =item my $service = $bus->get_service($name);
  286.  
  287. Retrieves a handle for the remote service identified by the
  288. service name C<$name>. The returned object will be an instance
  289. of the L<Net::DBus::RemoteService> class.
  290.  
  291. =cut
  292.  
  293. sub get_service {
  294.     my $self = shift;
  295.     my $name = shift;
  296.  
  297.     if ($name eq "org.freedesktop.DBus") {
  298.     return $self->{bus};
  299.     }
  300.  
  301.     my $owner = $name;
  302.     if ($owner !~ /^:/) {
  303.     $owner = $self->get_service_owner($name);
  304.     if (!$owner) {
  305.         $self->get_bus_object->StartServiceByName($name, 0);
  306.         $owner = $self->get_service_owner($name);
  307.     }
  308.     }
  309.  
  310.     unless (exists $self->{services}->{$owner}) {
  311.     $self->{services}->{$owner} = Net::DBus::RemoteService->new($self, $owner, $name);
  312.     }
  313.     return $self->{services}->{$owner};
  314. }
  315.  
  316. =item my $service = $bus->export_service($name);
  317.  
  318. Registers a service with the bus, returning a handle to
  319. the service. The returned object is an instance of the
  320. L<Net::DBus::Service> class.
  321.  
  322. =cut
  323.  
  324. sub export_service {
  325.     my $self = shift;
  326.     my $name = shift;
  327.     return Net::DBus::Service->new($self, $name);
  328. }
  329.  
  330. =item my $object = $bus->get_bus_object;
  331.  
  332. Retrieves a handle to the bus object, C</org/freedesktop/DBus>,
  333. provided by the service C<org.freedesktop.DBus>. The returned
  334. object is an instance of L<Net::DBus::RemoteObject>
  335.  
  336. =cut
  337.  
  338. sub get_bus_object {
  339.     my $self = shift;
  340.  
  341.     my $service = $self->get_service("org.freedesktop.DBus");
  342.     return $service->get_object('/org/freedesktop/DBus',
  343.                 'org.freedesktop.DBus');
  344. }
  345.  
  346.  
  347. =item my $name = $bus->get_unique_name;
  348.  
  349. Retrieves the unique name of this client's connection to
  350. the bus.
  351.  
  352. =cut
  353.  
  354. sub get_unique_name {
  355.     my $self = shift;
  356.  
  357.     return $self->get_connection->get_unique_name
  358. }
  359.  
  360. =item my $name = $bus->get_service_owner($service);
  361.  
  362. Retrieves the unique name of the client on the bus owning
  363. the service named by the C<$service> parameter.
  364.  
  365. =cut
  366.  
  367. sub get_service_owner {
  368.     my $self = shift;
  369.     my $service = shift;
  370.  
  371.     my $bus = $self->get_bus_object;
  372.     my $owner = eval {
  373.     $bus->GetNameOwner($service);
  374.     };
  375.     if ($@) {
  376.     if (UNIVERSAL::isa($@, "Net::DBus::Error") &&
  377.         $@->{name} eq "org.freedesktop.DBus.Error.NameHasNoOwner") {
  378.         $owner = undef;
  379.     } else {
  380.         die $@;
  381.     }
  382.     }
  383.     return $owner;
  384. }
  385.  
  386.  
  387. sub _add_signal_receiver {
  388.     my $self = shift;
  389.     my $receiver = shift;
  390.     my $signal_name = shift;
  391.     my $interface = shift;
  392.     my $service = shift;
  393.     my $path = shift;
  394.  
  395.     my $rule = $self->_match_rule($signal_name, $interface, $service, $path);
  396.  
  397.     push @{$self->{signals}}, [$receiver, $rule, $signal_name, $interface, $service, $path];
  398.     $self->{connection}->add_match($rule);
  399. }
  400.  
  401. sub _remove_signal_receiver {
  402.     my $self = shift;
  403.     my $receiver = shift;
  404.     my $signal_name = shift;
  405.     my $interface = shift;
  406.     my $service = shift;
  407.     my $path = shift;
  408.  
  409.     my $rule = $self->_match_rule($signal_name, $interface, $service, $path);
  410.  
  411.     my @signals;
  412.     foreach (@{$self->{signals}}) {
  413.     if ($_->[0] eq $receiver &&
  414.         defined $_->[1] &&
  415.         $_->[1] eq $rule) {
  416.         $self->{connection}->remove_match($rule);
  417.     } else {
  418.         push @signals, $_;
  419.     }
  420.     }
  421.     $self->{signals} = \@signals;
  422. }
  423.  
  424.  
  425. sub _match_rule {
  426.     my $self = shift;
  427.     my $signal_name = shift;
  428.     my $interface = shift;
  429.     my $service = shift;
  430.     my $path = shift;
  431.  
  432.     my $rule = "type='signal'";
  433.     if ($interface) {
  434.     $rule .= ",interface='$interface'";
  435.     }
  436.     if ($service) {
  437.     if ($service !~ /^:/) {
  438.         # Resolve service name to a client id
  439.         $service = $self->get_service_owner($service);
  440.     }
  441.     if ($service) {
  442.         $rule .= ",sender='$service'";
  443.     }
  444.     }
  445.     if ($path) {
  446.     $rule .= ",path='$path'";
  447.     }
  448.     if ($signal_name) {
  449.     $rule .= ",member='$signal_name'";
  450.     }
  451.     return $rule;
  452. }
  453.  
  454.  
  455. sub _rule_matches {
  456.     my $self = shift;
  457.     my $rule = shift;
  458.     my $member = shift;
  459.     my $interface = shift;
  460.     my $sender = shift;
  461.     my $path = shift;
  462.  
  463.     my %bits;
  464.     map {
  465.     if (/^(\w+)='(.*)'$/) {
  466.         $bits{$1} = $2;
  467.     }
  468.     } split /,/, $rule;
  469.  
  470.  
  471.     if (exists $bits{member} &&
  472.     $bits{member} ne $member) {
  473.     return 0;
  474.     }
  475.     if (exists $bits{interface} &&
  476.     $bits{interface} ne $interface) {
  477.     return 0;
  478.     }
  479.     if (exists $bits{sender} &&
  480.     $bits{sender} ne $sender) {
  481.     return 0;
  482.     }
  483.     if (exists $bits{path} &&
  484.     $bits{path} ne $path) {
  485.     return 0;
  486.     }
  487.     return 1;
  488. }
  489.  
  490. sub _signal_func {
  491.     my $self = shift;
  492.     my $connection = shift;
  493.     my $message = shift;
  494.  
  495.     return 0 unless $message->get_type() == &Net::DBus::Binding::Message::MESSAGE_TYPE_SIGNAL;
  496.  
  497.     my $interface = $message->get_interface;
  498.     my $sender = $message->get_sender;
  499.     my $path = $message->get_path;
  500.     my $member = $message->get_member;
  501.  
  502.     my $handled = 0;
  503.     foreach my $handler (grep { defined $_->[1] &&
  504.                 $self->_rule_matches($_->[1], $member, $interface, $sender, $path) }
  505.              @{$self->{signals}}) {
  506.     my $callback = $handler->[0];
  507.     &$callback($message);
  508.     $handled = 1;
  509.     }
  510.  
  511.     return $handled;
  512. }
  513.  
  514. =back
  515.  
  516. =head1 DATA TYPING METHODS
  517.  
  518. These methods are not usually used, since most services provide introspection
  519. data to inform clients of their data typing requirements. If introspection data
  520. is incomplete, however, it may be neccessary for a client to mark values with
  521. specific data types. In such a case, the following methods can be used. They
  522. are not, however, exported by default so must be requested at import time by
  523. specifying 'use Net::DBus qw(:typing)'
  524.  
  525. =over 4
  526.  
  527. =item $typed_value = dbus_int16($value);
  528.  
  529. Mark a value as being a signed, 16-bit integer.
  530.  
  531. =cut
  532.  
  533. sub dbus_int16 {
  534.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_INT16,
  535.                       $_[0]);
  536.  
  537. }
  538.  
  539. =item $typed_value = dbus_uint16($value);
  540.  
  541. Mark a value as being an unsigned, 16-bit integer.
  542.  
  543. =cut
  544.  
  545.  
  546. sub dbus_uint16 {
  547.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_UINT16,
  548.                       $_[0]);
  549. }
  550.  
  551. =item $typed_value = dbus_int32($value);
  552.  
  553. Mark a value as being a signed, 32-bit integer.
  554.  
  555. =cut
  556.  
  557. sub dbus_int32 {
  558.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_INT32,
  559.                       $_[0]);
  560.  
  561. }
  562.  
  563. =item $typed_value = dbus_uint32($value);
  564.  
  565. Mark a value as being an unsigned, 32-bit integer.
  566.  
  567. =cut
  568.  
  569.  
  570. sub dbus_uint32 {
  571.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_UINT32,
  572.                       $_[0]);
  573. }
  574.  
  575. =item $typed_value = dbus_int64($value);
  576.  
  577. Mark a value as being an unsigned, 64-bit integer.
  578.  
  579. =cut
  580.  
  581.  
  582.  
  583. sub dbus_int64 {
  584.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_INT64,
  585.                       $_[0]);
  586.  
  587. }
  588.  
  589. =item $typed_value = dbus_uint64($value);
  590.  
  591. Mark a value as being an unsigned, 64-bit integer.
  592.  
  593. =cut
  594.  
  595.  
  596.  
  597. sub dbus_uint64 {
  598.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_UINT64,
  599.                       $_[0]);
  600. }
  601.  
  602. =item $typed_value = dbus_double($value);
  603.  
  604. Mark a value as being a double precision IEEE floating point.
  605.  
  606. =cut
  607.  
  608.  
  609.  
  610. sub dbus_double {
  611.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_DOUBLE,
  612.                       $_[0]);
  613. }
  614.  
  615. =item $typed_value = dbus_byte($value);
  616.  
  617. Mark a value as being an unsigned, byte.
  618.  
  619. =cut
  620.  
  621.  
  622.  
  623. sub dbus_byte {
  624.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_BYTE,
  625.                       $_[0]);
  626. }
  627.  
  628. =item $typed_value = dbus_string($value);
  629.  
  630. Mark a value as being a UTF-8 string. This is not usually required
  631. since 'string' is the default data type for any Perl scalar value.
  632.  
  633. =cut
  634.  
  635.  
  636.  
  637. sub dbus_string {
  638.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_STRING,
  639.                       $_[0]);
  640. }
  641.  
  642. =item $typed_value = dbus_signature($value);
  643.  
  644. Mark a value as being a UTF-8 string, whose contents is a valid
  645. type signature
  646.  
  647. =cut
  648.  
  649.  
  650.  
  651. sub dbus_signature {
  652.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_SIGNATURE,
  653.                       $_[0]);
  654. }
  655.  
  656. =item $typed_value = dbus_object_path($value);
  657.  
  658. Mark a value as being a UTF-8 string, whose contents is a valid
  659. object path.
  660.  
  661. =cut
  662.  
  663. sub dbus_object_path {
  664.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_OBJECT_PATH,
  665.                       $_[0]);
  666. }
  667.  
  668. =item $typed_value = dbus_boolean($value);
  669.  
  670. Mark a value as being an boolean
  671.  
  672. =cut
  673.  
  674.  
  675.  
  676. sub dbus_boolean {
  677.     return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_BOOLEAN,
  678.                       $_[0]);
  679. }
  680.  
  681. =item $typed_value = dbus_array($value);
  682.  
  683. Mark a value as being an array
  684.  
  685. =cut
  686.  
  687.  
  688. sub dbus_array {
  689.     return Net::DBus::Binding::Value->new([&Net::DBus::Binding::Message::TYPE_ARRAY],
  690.                       $_[0]);
  691. }
  692.  
  693. =item $typed_value = dbus_struct($value);
  694.  
  695. Mark a value as being a structure
  696.  
  697. =cut
  698.  
  699.  
  700. sub dbus_struct {
  701.     return Net::DBus::Binding::Value->new([&Net::DBus::Binding::Message::TYPE_STRUCT],
  702.                       $_[0]);
  703. }
  704.  
  705. =item $typed_value = dbus_dict($value);
  706.  
  707. Mark a value as being a dictionary
  708.  
  709. =cut
  710.  
  711. sub dbus_dict{
  712.     return Net::DBus::Binding::Value->new([&Net::DBus::Binding::Message::TYPE_DICT_ENTRY],
  713.                       $_[0]);
  714. }
  715.  
  716. =item $typed_value = dbus_variant($value);
  717.  
  718. Mark a value as being a variant
  719.  
  720. =cut
  721.  
  722. sub dbus_variant{
  723.     return Net::DBus::Binding::Value->new([&Net::DBus::Binding::Message::TYPE_VARIANT],
  724.                       $_[0]);
  725. }
  726.  
  727. =pod
  728.  
  729. =back
  730.  
  731. =head1 SEE ALSO
  732.  
  733. L<Net::DBus>, L<Net::DBus::RemoteService>, L<Net::DBus::Service>,
  734. L<Net::DBus::RemoteObject>, L<Net::DBus::Object>,
  735. L<Net::DBus::Exporter>, L<Net::DBus::Dumper>, L<Net::DBus::Reactor>,
  736. C<dbus-monitor(1)>, C<dbus-daemon-1(1)>, C<dbus-send(1)>, L<http://dbus.freedesktop.org>,
  737.  
  738. =head1 AUTHOR
  739.  
  740. Daniel Berrange <dan@berrange.com>
  741.  
  742. =head1 COPYRIGHT
  743.  
  744. Copyright 2004-2005 by Daniel Berrange
  745.  
  746. =cut
  747.  
  748. 1;
  749.